In many computing systems, low level instruction code is used as an intermediary between the hardware components of the computing system and the operating software and other high level software executing on the computing system. In some computer systems, this low level instruction code is known as the Basic Input/Output System (“BIOS”). The BIOS provides a set of software routines that allow high level software to interact with the hardware components of the computing system using standard calls. BIOS-compatible firmware implementations may be referred to herein as “legacy BIOS.”
Because of limitations of the BIOS utilized in many PC-compatible computers, a new firmware architecture for booting the computer and for intermediating the communication between the operating system and the hardware has been proposed. The new architecture is defined via a set of specifications. One of the specifications is called the Extensible Firmware Interface (“EFI”) specification and is available from INTEL CORPORATION. The original EFI Specification from INTEL CORPORATION is also being extended by the Unified Extensible Firmware Interface Forum (“UEFI”).
The EFI specification describes an EFI environment that provides an interface between the operating system and the system firmware. In particular, the EFI specification defines the interface that platform firmware must implement and the interface that the operating system may use in booting. How the firmware implements the interface is left up to the manufacturer of the firmware. The EFI specification provides protocols for EFI drivers to communicate with each other, and the EFI core provides functions such as allocation of memory, creating events, setting the clock, and many others. This is accomplished through a formal and complete abstract specification of the software-visible interface presented to the operating system by the platform and the firmware.
Additional details regarding the EFI and UEFI firmware architecture are defined by the group of specifications called INTEL Platform Innovation Framework for EFI (“the Framework”) and available from INTEL CORPORATION. Unlike the EFI Specification, which focuses on programmatic interfaces for the interactions between the operating system and system firmware, the Framework defines programmatic interfaces to perform the full range of operations that are required to initialize the platform from power on through transfer of control to the operating system.
In general, the storage repository for firmware code and/or data of the Framework is a firmware volume. A firmware volume may be formed from a single firmware device, multiple firmware devices, or a firmware device divided into smaller pieces to form multiple logical firmware devices. Each firmware volume is organized into a Firmware File System (“FFS”) including multiple FFS files. Typically, the FFS files of a firmware volume include a header and at least one section for storing the firmware code and/or data. The firmware code and/or data may be included in executable files or firmware modules. Therefore, sections of an FFS file may include executable files or firmware modules.
Often, the firmware source code represented in the executable files of the FFS file sections is associated with data that is separate from but needs to remain connected with the firmware source code so that the data can be used by the firmware source code once converted to an executable format. For example, such data may include scripts that define a page of the firmware setup utility, central processing unit (“CPU”) microcode which includes code supplied directly to the CPU, a firmware logo, or audio files. This data may be converted to a computer programming language, such as C programming language, and then compiled with the firmware source code to form an executable file. However, when the data is converted to a computer programming language and compiled with the firmware source code, the data often becomes indistinguishable from the firmware source code. Therefore, there is a need to convert and compile data associated with a firmware source code such that the data remains connected with but distinguishable from the firmware source code.